home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / posixpath.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  8KB  |  383 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import os
  5. import stat
  6. __all__ = [
  7.     'normcase',
  8.     'isabs',
  9.     'join',
  10.     'splitdrive',
  11.     'split',
  12.     'splitext',
  13.     'basename',
  14.     'dirname',
  15.     'commonprefix',
  16.     'getsize',
  17.     'getmtime',
  18.     'getatime',
  19.     'getctime',
  20.     'islink',
  21.     'exists',
  22.     'lexists',
  23.     'isdir',
  24.     'isfile',
  25.     'ismount',
  26.     'walk',
  27.     'expanduser',
  28.     'expandvars',
  29.     'normpath',
  30.     'abspath',
  31.     'samefile',
  32.     'sameopenfile',
  33.     'samestat',
  34.     'curdir',
  35.     'pardir',
  36.     'sep',
  37.     'pathsep',
  38.     'defpath',
  39.     'altsep',
  40.     'extsep',
  41.     'devnull',
  42.     'realpath',
  43.     'supports_unicode_filenames']
  44. curdir = '.'
  45. pardir = '..'
  46. extsep = '.'
  47. sep = '/'
  48. pathsep = ':'
  49. defpath = ':/bin:/usr/bin'
  50. altsep = None
  51. devnull = '/dev/null'
  52.  
  53. def normcase(s):
  54.     return s
  55.  
  56.  
  57. def isabs(s):
  58.     return s.startswith('/')
  59.  
  60.  
  61. def join(a, *p):
  62.     path = a
  63.     for b in p:
  64.         if b.startswith('/'):
  65.             path = b
  66.             continue
  67.         if path == '' or path.endswith('/'):
  68.             path += b
  69.             continue
  70.         path += '/' + b
  71.     
  72.     return path
  73.  
  74.  
  75. def split(p):
  76.     i = p.rfind('/') + 1
  77.     head = p[:i]
  78.     tail = p[i:]
  79.     if head and head != '/' * len(head):
  80.         head = head.rstrip('/')
  81.     
  82.     return (head, tail)
  83.  
  84.  
  85. def splitext(p):
  86.     i = p.rfind('.')
  87.     if i <= p.rfind('/'):
  88.         return (p, '')
  89.     else:
  90.         return (p[:i], p[i:])
  91.  
  92.  
  93. def splitdrive(p):
  94.     return ('', p)
  95.  
  96.  
  97. def basename(p):
  98.     return split(p)[1]
  99.  
  100.  
  101. def dirname(p):
  102.     return split(p)[0]
  103.  
  104.  
  105. def commonprefix(m):
  106.     if not m:
  107.         return ''
  108.     
  109.     s1 = min(m)
  110.     s2 = max(m)
  111.     n = min(len(s1), len(s2))
  112.     for i in xrange(n):
  113.         if s1[i] != s2[i]:
  114.             return s1[:i]
  115.             continue
  116.     
  117.     return s1[:n]
  118.  
  119.  
  120. def getsize(filename):
  121.     return os.stat(filename).st_size
  122.  
  123.  
  124. def getmtime(filename):
  125.     return os.stat(filename).st_mtime
  126.  
  127.  
  128. def getatime(filename):
  129.     return os.stat(filename).st_atime
  130.  
  131.  
  132. def getctime(filename):
  133.     return os.stat(filename).st_ctime
  134.  
  135.  
  136. def islink(path):
  137.     
  138.     try:
  139.         st = os.lstat(path)
  140.     except (os.error, AttributeError):
  141.         return False
  142.  
  143.     return stat.S_ISLNK(st.st_mode)
  144.  
  145.  
  146. def exists(path):
  147.     
  148.     try:
  149.         st = os.stat(path)
  150.     except os.error:
  151.         return False
  152.  
  153.     return True
  154.  
  155.  
  156. def lexists(path):
  157.     
  158.     try:
  159.         st = os.lstat(path)
  160.     except os.error:
  161.         return False
  162.  
  163.     return True
  164.  
  165.  
  166. def isdir(path):
  167.     
  168.     try:
  169.         st = os.stat(path)
  170.     except os.error:
  171.         return False
  172.  
  173.     return stat.S_ISDIR(st.st_mode)
  174.  
  175.  
  176. def isfile(path):
  177.     
  178.     try:
  179.         st = os.stat(path)
  180.     except os.error:
  181.         return False
  182.  
  183.     return stat.S_ISREG(st.st_mode)
  184.  
  185.  
  186. def samefile(f1, f2):
  187.     s1 = os.stat(f1)
  188.     s2 = os.stat(f2)
  189.     return samestat(s1, s2)
  190.  
  191.  
  192. def sameopenfile(fp1, fp2):
  193.     s1 = os.fstat(fp1)
  194.     s2 = os.fstat(fp2)
  195.     return samestat(s1, s2)
  196.  
  197.  
  198. def samestat(s1, s2):
  199.     if s1.st_ino == s2.st_ino:
  200.         pass
  201.     return s1.st_dev == s2.st_dev
  202.  
  203.  
  204. def ismount(path):
  205.     
  206.     try:
  207.         s1 = os.lstat(path)
  208.         s2 = os.lstat(join(path, '..'))
  209.     except os.error:
  210.         return False
  211.  
  212.     dev1 = s1.st_dev
  213.     dev2 = s2.st_dev
  214.     if dev1 != dev2:
  215.         return True
  216.     
  217.     ino1 = s1.st_ino
  218.     ino2 = s2.st_ino
  219.     if ino1 == ino2:
  220.         return True
  221.     
  222.     return False
  223.  
  224.  
  225. def walk(top, func, arg):
  226.     
  227.     try:
  228.         names = os.listdir(top)
  229.     except os.error:
  230.         return None
  231.  
  232.     func(arg, top, names)
  233.     for name in names:
  234.         name = join(top, name)
  235.         
  236.         try:
  237.             st = os.lstat(name)
  238.         except os.error:
  239.             continue
  240.  
  241.         if stat.S_ISDIR(st.st_mode):
  242.             walk(name, func, arg)
  243.             continue
  244.     
  245.  
  246.  
  247. def expanduser(path):
  248.     if not path.startswith('~'):
  249.         return path
  250.     
  251.     i = path.find('/', 1)
  252.     if i < 0:
  253.         i = len(path)
  254.     
  255.     if i == 1:
  256.         if 'HOME' not in os.environ:
  257.             import pwd as pwd
  258.             userhome = pwd.getpwuid(os.getuid()).pw_dir
  259.         else:
  260.             userhome = os.environ['HOME']
  261.     else:
  262.         import pwd as pwd
  263.         
  264.         try:
  265.             pwent = pwd.getpwnam(path[1:i])
  266.         except KeyError:
  267.             return path
  268.  
  269.         userhome = pwent.pw_dir
  270.     userhome = userhome.rstrip('/')
  271.     return userhome + path[i:]
  272.  
  273. _varprog = None
  274.  
  275. def expandvars(path):
  276.     global _varprog
  277.     if '$' not in path:
  278.         return path
  279.     
  280.     if not _varprog:
  281.         import re as re
  282.         _varprog = re.compile('\\$(\\w+|\\{[^}]*\\})')
  283.     
  284.     i = 0
  285.     while True:
  286.         m = _varprog.search(path, i)
  287.         if not m:
  288.             break
  289.         
  290.         (i, j) = m.span(0)
  291.         name = m.group(1)
  292.         if name.startswith('{') and name.endswith('}'):
  293.             name = name[1:-1]
  294.         
  295.         if name in os.environ:
  296.             tail = path[j:]
  297.             path = path[:i] + os.environ[name]
  298.             i = len(path)
  299.             path += tail
  300.             continue
  301.         i = j
  302.     return path
  303.  
  304.  
  305. def normpath(path):
  306.     if path == '':
  307.         return '.'
  308.     
  309.     initial_slashes = path.startswith('/')
  310.     if initial_slashes and path.startswith('//') and not path.startswith('///'):
  311.         initial_slashes = 2
  312.     
  313.     comps = path.split('/')
  314.     new_comps = []
  315.     for comp in comps:
  316.         if comp in ('', '.'):
  317.             continue
  318.         
  319.         if not comp != '..':
  320.             if (not initial_slashes or not new_comps or new_comps) and new_comps[-1] == '..':
  321.                 new_comps.append(comp)
  322.                 continue
  323.         if new_comps:
  324.             new_comps.pop()
  325.             continue
  326.     
  327.     comps = new_comps
  328.     path = '/'.join(comps)
  329.     if initial_slashes:
  330.         path = '/' * initial_slashes + path
  331.     
  332.     if not path:
  333.         pass
  334.     return '.'
  335.  
  336.  
  337. def abspath(path):
  338.     if not isabs(path):
  339.         path = join(os.getcwd(), path)
  340.     
  341.     return normpath(path)
  342.  
  343.  
  344. def realpath(filename):
  345.     if isabs(filename):
  346.         bits = [
  347.             '/'] + filename.split('/')[1:]
  348.     else:
  349.         bits = [
  350.             ''] + filename.split('/')
  351.     for i in range(2, len(bits) + 1):
  352.         component = join(*bits[0:i])
  353.         if islink(component):
  354.             resolved = _resolve_link(component)
  355.             if resolved is None:
  356.                 return abspath(join(*[
  357.                     component] + bits[i:]))
  358.             else:
  359.                 newpath = join(*[
  360.                     resolved] + bits[i:])
  361.                 return realpath(newpath)
  362.         resolved is None
  363.     
  364.     return abspath(filename)
  365.  
  366.  
  367. def _resolve_link(path):
  368.     paths_seen = []
  369.     while islink(path):
  370.         if path in paths_seen:
  371.             return None
  372.         
  373.         paths_seen.append(path)
  374.         resolved = os.readlink(path)
  375.         if not isabs(resolved):
  376.             dir = dirname(path)
  377.             path = normpath(join(dir, resolved))
  378.             continue
  379.         path = normpath(resolved)
  380.     return path
  381.  
  382. supports_unicode_filenames = False
  383.